/***************Array扩展*****************/
var slice = Array.prototype.slice;
/**
 *
 * @param item
 * @returns {number}
 */
Array.prototype.indexOf = function (item) {
    for (var i = 0, len = this.length; i < len; i++) {
        if (this[i] == item) {
            return i;
        }
    }
    return -1;
};

Array.prototype.size = function () {
    return this.length;
};
/**
 * 清空数组
 * @returns {Array}
 */
Array.prototype.clear = function () {
    this.length = 0;
    return this;
};
/**
 * 克隆一个数组
 * @returns {Array.<T>}
 */
Array.prototype.clone = function () {
    return slice.call(this, 0);
};
/**
 * 按条件过渡数组
 * @param fun
 * @returns {Array}
 */
Array.prototype.filter = function (fun) {
    var values = [];
    for (var i = 0, len = this.length; i < len; i++) {
        if (fun.call(null, this[i], i,this)) {
            values.push(this[i]);
        }
    }
    return values;
};
Array.prototype.compact=function(){
    var func = function(item,index,array){
        if(isEmpty(item)){
            return false;
        }
        return true;
    };
    return this.filter(func);
}
/**
 * 如果数组中的每个元素都能通过给定的函数的测试，则返回true，反之false。
 * 换言之给定的函数也一定要返回true与false
 * @param fn
 * @param thisObj
 * @returns {boolean}
 */
Array.prototype.every = function(fn) {
    for ( var i=0, j=this.length; i < j; ++i ) {
        if ( !fn.call(null,this[i], i, this) ) {
            return false;
        }
    }
    return true;
};
/**
 * 类似every函数，但只要有一个通过给定函数的测试就返回true
 * @param fn
 * @param thisObj
 * @returns {boolean}
 */
Array.prototype.some = function(fn) {

    for ( var i=0, j=this.length; i < j; ++i ) {
        if ( fn.call(null, this[i], i, this) ) {
            return true;
        }
    }
    return false;
};
/**
 * 扩展Array类,实现一个each函数，
 * @param fun
 */
Array.prototype.each=function( fun ){
    for( var i=0,n=this.length;i<n;i++){
        fun.call(null,this[i], i, this);
    }
};
/**
 * 让数组中的每一个元素调用给定的函数，然后把得到的结果放到新数组中返回
 * @param fn
 * @param thisObj
 * @returns {Array}
 */
Array.prototype.map = function(fn) {
    var a = [];
    for ( var i=0, j=this.length; i < j; ++i ) {
        a.push(fn.call(null, this[i], i, this));
    }
    return a;
};
/**
 *
 * @param item
 * @returns {*}
 */
Array.prototype.remove = function (item) {
    var itemIndex = this.indexOf(item);
    if (itemIndex >= 0) {
        this.splice(itemIndex, 1);
        return itemIndex;
    }
    return -1;
};
/**
 *
 * @param arr
 */
Array.prototype.removeAll = function (arr) {
    for (var i = 0, len = arr.length; i < len; i++) {
        this.remove(arr[i]);
    }
};

Array.prototype.notempty = function () {
    for (var i = 0; i < this.length; i++) {
        if (isEmpty(this[i])) {
            this.splice(i);
        }
    }
    return this;
}

/**
 *
 * @param item
 */
Array.prototype.add = function (item) {
    this.push(item);
};
/**
 *
 * @param arr
 */
Array.prototype.addAll = function (arr) {
    for (var i = 0;i < arr.length; i++) {
        this.add(arr[i]);
    }
};
/**
 * 删除数组中指定索引的数据
 * @param index
 * @returns {*}
 */
Array.prototype.deleteAt = function (index) {
    if (index < 0) {
        return this;
    }
    return this.slice(0, index).concat(this.slice(index + 1, this.length));
};
/**
 * 数组洗牌
 * @returns {Array}
 */
Array.prototype.random = function () {
    var tempArr = [], me = this, t;
    while (me.length > 0) {
        t = Math.floor(Math.random() * me.length);
        tempArr[tempArr.length] = me[t];
        me = me.deleteAt(t);
    }
    return tempArr;
};
/**
 * 数字数组排序
 * @param i
 * @returns {Array.<T>}
 */
Array.prototype.sortNum = function (i) {
    if (!i) {
        i = 0;
    }
    if (i == 1) {
        return this.sort(function (a, b) {
            return b - a;
        });
    }
    return this.sort(function (a, b) {
        return a - b;
    });
};
/**
 * 获取数字数组中的最大项
 * @returns {T}
 */
Array.prototype.getMax = function () {
    return this.sortNum(1)[0];
};
/**
 * 获取数字数组中的最小项
 * @returns {T}
 */
Array.prototype.getMin = function () {
    return this.sortNum(0)[0];
};
/**
 * 去除数组中的重复项
 * @returns {Array}
 */
Array.prototype.arrUnique = function () {
    var reset = [], done = {};
    for (var i = 0; i < this.length; i++) {
        var temp = this[i];
        if (!done[temp]) {
            done[temp] = true;
            reset.push(temp);
        }
    }
    return reset;
};
/**
 * 判断是否存在,通过元素的id
 * @param elementId
 * @returns {*}
 */
Array.prototype.getElementById=function(elementId){
    for(var i=0;i<this.length;i++){
        if(this[i].id== elementId){
            return this[i];
        }
    }
};
/**
 * 确定某个元素是否在数组中
 * @param element
 * @returns {boolean}
 */
Array.prototype.contains=function(element){
    for(var i=0;i<this.length;i++){
        if(this[i]== element){
            return true;
        }
    }
    return false;
};
/**
 * 判断是否存在,通过元素的id
 * @param elementId
 * @returns {boolean}
 */
Array.prototype.containsById=function(elementId){
    for(var i=0;i<this.length;i++){
        if(this[i].id== elementId){
            return true;
        }
    }
    return false;
};
/**
 * 删除Array的元素,通过元素的Id
 * @param elementId
 */
Array.prototype.removeById=function(elementId){
    for(var i=0;i<this.length;i++){
        if(this[i].id == elementId){
            this.splice(i,1);
        }
    }
};